{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第2章 卷积"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 简介"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在如今计算机视觉领域，卷积（convolution）可能是出现得最频繁的术语。当然这是因为卷积神经网络被广泛地用于解决多种计算机视觉任务，已经成为计算机视觉领域的一种默认的工具。但是卷积这个术语并不来自于计算机科学领域，而是来自于信号处理领域。卷积是信号处理中的一个重要操作，用于计算线性系统对输入信号的输出响应。什么是卷积呢？顾名思义，就是先“卷”，再“积”。用专业术语来说，卷积的输入是两个函数，一个为输入信号函数，另一个为系统函数，卷积操作先将一个函数翻转，然后将其对另一个函数进行滑动叠加，最后得到输出结果（如图 2-1）。在函数连续的情况下，叠加指的是对两个函数的乘积求积分；而在离散情况下是对函数加权求和，为简单起见我们统一称之为叠加。\n",
    "\n",
    "\n",
    "<center>\n",
    "    <img style=\"border-radius: 0.3125em;\" \n",
    "    src=\"https://storage.googleapis.com/kagglesdsdata/datasets/2171976/3643430/pic1.png?X-Goog-Algorithm=GOOG4-RSA-SHA256&X-Goog-Credential=databundle-worker-v2%40kaggle-161607.iam.gserviceaccount.com%2F20220522%2Fauto%2Fstorage%2Fgoog4_request&X-Goog-Date=20220522T053420Z&X-Goog-Expires=345599&X-Goog-SignedHeaders=host&X-Goog-Signature=99a1f64fa0a5a4bebca2570a97c4f8bdbbca635f793026360fb565b13db12f469400347f0ff89639a4283507a6abb1fcf0577d3b3c5eca9e74b3ffb5d73282f03c6eb5a67010a571ea3c95e59c87335479ce122ae25e29db198e6fb80d6dcb2e1fe6a6e51db47f6f382fd1ca533700e814a5e4a27c3a797cc7cde718f64274c4ce3226afe1ef343e91bacd61b4997303ae6c6596c7e9726570cef86777288313e88e592f0e646e629c6193b7535dc7c0e14febef554cbf1cbb858816398881efa142060cbe3e97c9c0d6568c000cd6e2d7500161a474eb357fe252de505c1edd4fc9c48fcf9d5af2162d3d3d8cf136fb73f2e0bd2aec0ac40d2870e1cd5a74d8\" width=600>\n",
    "    <br>\n",
    "    <div style=\"color:orange; \n",
    "    display: inline-block;\n",
    "    color: #999;\n",
    "    padding: 2px;\">图2-1 输入信号函数和系统函数的卷积</div>\n",
    "</center>\n",
    "\n",
    "\n",
    "那么卷积这样一个操作有什么意义呢？为什么要先对输入的函数进行翻转呢？信号处理的教材通常会这样解释：卷积的结果不仅仅和当前输入的信号响应值有关，也和该信号在过去所有时刻的输入响应值有关系。这表明卷积不仅仅考虑当下的情况，也考虑过去时刻的情况，它是一种对相应效果的累积，所以有一个先“卷”再“积”的过程。这么描述仍然很抽象，我们举一个实际生活中的例子。试想你站在一个池塘边，往池塘里扔石子。扔一颗石子，池塘里就会产生水波，然后慢慢衰退，水面重新平静。这里扔石子就是输入信号，产生的水波就是对输入的响应。那么如果按一定速度不停地往池塘中扔石子呢？这种情况下，在水面上某处某一时刻的水波的大小如何计算？根据常识，我们知道当前时刻某处的水波大小不但和当前时刻扔的石子产生的水波有关，还和之前所有扔的石子产生的水波有关，是这些水波的累积结果。这便是先“卷”再“积”的过程，“卷”考虑了与当前输入相关的所有输入，而“积”则把这些输入的效果进行叠加。\n",
    "\n",
    "类似的，在图像处理中，卷积的计算是把每个像素一个邻域内的像素值进行加权求和。这里空间上的邻域就对应于时间上的前后时刻，图像就是输入信号函数，加权的权重就是系统函数，卷积的结果就是系统函数对输入图像的响应，也就是图像特征。由此可见，对图像进行卷积就是提取图像特征的过程，这也是图像识别等计算机视觉任务的基础。\n",
    "\n",
    "在这一章节中，我们以一维卷积为引子，介绍卷积的数学定义与代码实现，然后推广到二维卷积，介绍对图像的卷积操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 一维卷积"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从数学上来说，卷积和加减乘除一样是一种运算，其运算的根本操作是将两个函数($f$和$k$)的其中一个先平移，然后再与另一个函数相称后的累加和。这个运算过程中，因为涉及到积分或者级数的操作，所以看起来很复杂。对于定义在连续域的函数，根据卷积的定义，一维卷积的公式如下：\n",
    "\n",
    "$$g(x) = f(x) * k(x) = \\int f(\\tau)k(x-\\tau)d\\tau$$\n",
    "\n",
    "在上式中，一维卷积的输入是一个一维信号$f(x)$和一个一维卷积核$k(x)$，在信号与系统中，$f(x)$是输入信号函数，$k(x)$是系统函数。我们可以很容易的看出，卷积是在（$-\\infty, \\infty$）上对$\\tau$求积分，积分对象为$f(\\tau)$和$k(x-\\tau)$的乘积。需要注意的是，等式右边只有$k(x-\\tau)$中提及了$x$，其余部分都在关注$\\tau$。\n",
    "\n",
    "\n",
    "根据连续函数一维卷积的公式，我们可以得出卷积操作的计算步骤如下：\n",
    "\n",
    "1. 变换：改变输入函数的横坐标，自变量由$x$变成$\\tau$；\n",
    "2. 反转：将其中一个函数反转；\n",
    "3. 平移：反转后的函数随变量$\\tau$平移，得到$k(x-\\tau)$。若$\\tau>0$，则向右平移，反之向左平移；\n",
    "4. 相乘：将$f(\\tau)$和$k(x-\\tau)$相乘；\n",
    "5. 积分：$f(\\tau)$和$k(x-\\tau)$乘积曲线下的面积即为在$x$位置的卷积值。\n",
    "\n",
    "同加减乘除一样，卷积作为一种计算操作，也有如下几种性质：\n",
    "1. 交换律：$f(x) * k(x) = k(x) * f(x)$；\n",
    "2. 结合律：$[f(x) * g(x)] * k(x) = f(x) * [g(x) * k(x)]$；\n",
    "3. 分配律：$f(x) * [g(x) + k(x)] = f(x) * g(x) + f(x) * k(x)$。\n",
    "\n",
    "<!-- 4. 微分:$\\frac{d}{dx}[f(x) * k(x)] = \\frac{df(x)}{dx} * k(x) = f(x) * \\frac{dk(x)}{dx}$ -->\n",
    "\n",
    "连续函数的一维卷积在音频处理等方面具有举足轻重的地位。但是，通常计算机所能处理的信号并不是连续的而是离散的，因此，接下来我们介绍离散型函数的一维卷积。\n",
    "\n",
    "根据卷积的定义，离散函数的一维卷积公式如下：\n",
    "\n",
    "$$\\mathbf{g}[i] = \\mathbf{f}[i] * \\mathbf{k}[i] = \\sum_{n} \\mathbf{f}[n]\\mathbf{k}[i-n]$$\n",
    "\n",
    "其中，与连续函数一维卷积不同的是，输入信号和卷积核是离散函数$\\mathbf{f}[i]$和$\\mathbf{k}[i]$（通常可用数组或者向量表示），而积分变成了求和。卷积核的长度一般是奇数，这是为了对称而设计的。通常情况下，输入信号$\\mathbf{f}[i]$的长度远远大于卷积核$\\mathbf{k}[i]$的长度。图 2-2 所示是离散函数一维卷积的计算过程。\n",
    "\n",
    "<center>\n",
    "    <img style=\"border-radius: 0.3125em;\" \n",
    "    src=\"https://storage.googleapis.com/kagglesdsdata/datasets/2171976/3676249/example.png?X-Goog-Algorithm=GOOG4-RSA-SHA256&X-Goog-Credential=databundle-worker-v2%40kaggle-161607.iam.gserviceaccount.com%2F20220522%2Fauto%2Fstorage%2Fgoog4_request&X-Goog-Date=20220522T054201Z&X-Goog-Expires=345599&X-Goog-SignedHeaders=host&X-Goog-Signature=2c68b0ae326f898675acd031ccd1f167cd14243663c004d279da7e4482fb0c79cfe20f8326a90ff91668b67fd152078695d47df0af16c0dede5faea7bca1197d3e7b429e52bf86ff39567b421b3f1e4a009f3591335ca30643640431010c42d582a039e705f848744bceb374d6767ecc0d1cb40b3add0fc7ec1952c90bbf03f0e5a1ccb70e77148b75f725de816bb8c2de7a1f39e54a38a3e54b956fb66e4caae6ad4ff1d1478304cdccafe3dd2fe6ee60cdcc2d566f017a056c329bc64e5506d701b874417b073c21a8fb074ecfab586058cbd7d0474a13e978a66793a4c35f6766b4f4f5de50eba3ea38e1eb9749975c4cdd89a0134a10afc1574b8e0a9da2\" width=500>\n",
    "    <br>\n",
    "    <div style=\"color:orange; \n",
    "    display: inline-block;\n",
    "    color: #999;\n",
    "    padding: 2px;\">图2-2 一维离散函数的卷积计算 </div>\n",
    "</center>\n",
    "\n",
    "\n",
    "由上图不难得出，对于离散变量，卷积可以理解为“卷和”，即相乘之后累加求和。除此之外，不知道大家是否注意到输出信号的长度和输入信号、卷积核之间的关系？\n",
    "\n",
    "假设输入信号长度为$m$，卷积核长度为$n$，按照图示方法，我们可以很容易的得到输出信号的长度为$m-n+1$。但这是不是意味着对一个输入信号反复卷积，它的输出长度将会越来越小？\n",
    "\n",
    "实际上，这种情况是确实可能存在的。因此，为了防止这种情况出现，我们通常会对输入信号进行“补零”（zero-padding）操作。对于图示输入，我们会在“1”的左边和“7”的右边各添加个数字“0”。如图 2-3 所示，如此一来输入信号的长度便增加了2，因此对应的输出信号长度也随之增加。补零操作让输出信号和输入信号的长度能够保持一致，更有甚者，如果我们对图示中输入信号的左右两边各添加两个“0”，输出信号的长度则大于输入信号。一般来说，在输入信号一边补零的个数要小于卷积核的长度。这是因为当长度超过或等于卷积核时，卷积所得的结果为0，相当于给输出信号也进行了补零操作，没有意义。更为直观的补零操作可以见二维卷积。\n",
    "\n",
    "\n",
    "<center>\n",
    "    <img style=\"border-radius: 0.3125em;\" \n",
    "    src=\"https://storage.googleapis.com/kagglesdsdata/datasets/2171976/3643430/zero.png?X-Goog-Algorithm=GOOG4-RSA-SHA256&X-Goog-Credential=databundle-worker-v2%40kaggle-161607.iam.gserviceaccount.com%2F20220522%2Fauto%2Fstorage%2Fgoog4_request&X-Goog-Date=20220522T053555Z&X-Goog-Expires=345599&X-Goog-SignedHeaders=host&X-Goog-Signature=6a23e63cb6aac90bb6c79f8b0b853beafb9619e90df5675ba6fae660876b4dead356b47cf348c4ad16172fb061c32bd78e738e3d87e9845c2e0ad101d8c27940de5f12666d6a537140ab458b2112d172b9ed9c9b87b1ce30a023994b14c4037e0fcbade16718a38f7bc513922e40ee95489929cdc47b2f2e84fc7646d40d124553d74252520dbfac4fbaf47eb30b72503af5d14e484970cf66481e690e488231a5fac8c6c71e89c143004418204cf0a82967d63b5dc574761d25b3b76d18e4f2f4d16c16f8f34eb068ae655586b138f590baac7a9a451249f605c444821029a7448cf2f8aa267cb880fc8ec66a368068efe8674c3421d5fd99018e4e5c5c44b5\" width=500>\n",
    "    <br>\n",
    "    <div style=\"color:orange; \n",
    "    display: inline-block;\n",
    "    color: #999;\n",
    "    padding: 2px;\">图2-3 输入信号的补零 </div>\n",
    "</center>\n",
    "\n",
    "\n",
    "\n",
    "根据以上定义，我们可以得出离散函数一维卷积的计算步骤：\n",
    "\n",
    "1. 变换：改变输入函数的横坐标，自变量由$i$变成$n$；\n",
    "2. 反转：将其中一个函数反转；\n",
    "3. 平移：反转后的函数随变量$n$平移，得到$\\mathbf{k}[i-n]$。若$n>0$，则向右平移，反之向左平移，且$n$为整数；\n",
    "4. 相乘：将$\\mathbf{f}[n]$和$\\mathbf{k}[i-n]$相乘；\n",
    "5. 累加：$\\mathbf{f}[n]$和$\\mathbf{k}[i-n]$乘积和的累加值即为在$n$位置的卷积值。\n",
    "\n",
    "\n",
    "接下来，我们将动手编写一维卷积函数。我们用数组表示离散函数，并对输入信号补零，补零的个数为卷积核长度减一，输出信号的长度为$m+2(n-1) - n + 1 = m+n-1$。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-24T11:34:38.646143Z",
     "iopub.status.busy": "2022-05-24T11:34:38.645730Z",
     "iopub.status.idle": "2022-05-24T11:34:38.679790Z",
     "shell.execute_reply": "2022-05-24T11:34:38.679354Z",
     "shell.execute_reply.started": "2022-05-24T11:34:38.646049Z"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "# 一维卷积\n",
    "class conv_1d():\n",
    "    def __init__(self, a, b):\n",
    "        self.a = a  # 输入信号\n",
    "        self.b = b  # 卷积核\n",
    "        self.ax = [i for i in range(len(a))]  # 输入信号的坐标，默认从0开始\n",
    "        self.bx = [i for i in range(len(b))]  # 卷积核的坐标，默认从0开始\n",
    "\n",
    "    def conv(self):\n",
    "        lst1 = self.a\n",
    "        lst2 = self.b\n",
    "        l1 = len(lst1)\n",
    "        l2 = len(lst2)\n",
    "        lst1 = [0] * (l2 - 1) + lst1 + [0] * (l2 - 1)\n",
    "        lst2.reverse()\n",
    "        c = [0 for x in range(0, l1 + l2 - 1)]\n",
    "        for i in range(l1 + l2 - 1):\n",
    "            for j in range(l2):\n",
    "                c[i] += lst1[i + j] * lst2[j]\n",
    "        return c\n",
    "\n",
    "    def plot(self):\n",
    "        a = self.a\n",
    "        b = self.b\n",
    "        ax = self.ax\n",
    "        bx = self.bx\n",
    "\n",
    "        # 为了更直观的查看结果，我们分别绘制a、b与它们卷积得到的信号\n",
    "        plt.figure(1)\n",
    "        plt.subplot(1, 2, 1)  # 图一包含1行2列子图，当前画在第一行第一列图上\n",
    "        plt.title('Input')\n",
    "        plt.bar(ax, a, color='lightcoral', width=0.2)\n",
    "        plt.plot(ax, a, color='lightcoral')\n",
    "\n",
    "        plt.figure(1)\n",
    "        plt.subplot(1, 2, 2)  # 当前画在第一行第2列图上\n",
    "        plt.title('Kernel')\n",
    "        plt.bar(bx, b, color='lightgreen', width=0.2)\n",
    "        #plt.plot(bx, b, color='lightgreen')\n",
    "\n",
    "\n",
    "        # 计算输出信号以及其坐标，并画图\n",
    "        c = self.conv()\n",
    "        length = len(c)\n",
    "        cx = [i for i in range(length)]\n",
    "        plt.figure()\n",
    "        plt.title('Output')\n",
    "        plt.bar(cx, c, color='lightseagreen', width=0.2)\n",
    "        plt.plot(cx, c, color='lightseagreen')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在我们举例来显示上述卷积实现的效果。我们用不同的卷积核去对一个三角波信号进行卷积，然后观察卷积的效果。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.1 冲激信号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-24T11:34:38.681075Z",
     "iopub.status.busy": "2022-05-24T11:34:38.680868Z",
     "iopub.status.idle": "2022-05-24T11:34:39.126887Z",
     "shell.execute_reply": "2022-05-24T11:34:39.126056Z",
     "shell.execute_reply.started": "2022-05-24T11:34:38.681048Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 定义输入信号与卷积核\n",
    "a = [0,1,2,3,2,1,0]\n",
    "\n",
    "# 冲激函数\n",
    "k = [0,0,1,0,0]\n",
    "\n",
    "conv = conv_1d(a, k)\n",
    "conv.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当我们所用的卷积核是一个单位冲激信号（即“面积”等于1只在一个位置出现的窄脉冲）时，输入信号在卷积之后并没有发生变化。这是卷积的一个重要性质，请大家记住。下面我们更换一下卷积核，看看输出会有什么不同的效果。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.2 方波信号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-24T11:34:39.128268Z",
     "iopub.status.busy": "2022-05-24T11:34:39.128027Z",
     "iopub.status.idle": "2022-05-24T11:34:39.668668Z",
     "shell.execute_reply": "2022-05-24T11:34:39.667651Z",
     "shell.execute_reply.started": "2022-05-24T11:34:39.128242Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dfZAk913f8fd3ZvqeT/egW53uee9pb2dN4YeohCilEsUPhSQT6Q8MkVK2sWNQIBbIhUPKJsRGgkBhEjsYK3aMbWRkx7aQKXIBgXEFGQNGQmchCd/27t7e4+496J6fH7Z75ps/Zva8Xu3tzO7OTPf0fF5VW56Z7u35SO75qPc3v+42d0dERNpfLukAIiLSGCp0EZGMUKGLiGSECl1EJCNU6CIiGaFCFxHJCBW6iLQ1M/uWmf1M0jnSQIXeYmZ2wMze2uT3+DUz+1Iz30Nk8r5sZg+Y2Rkz+5dJ5upkKnQRmTMz+2ngceDt7v7XM/g9MzP1UIPoX2RCzOw9Zva3Zvbfqkc1+83sngnLv2Vmv2Vm/2Bm583s/5jZyuqyu8xsdNL2DpjZW83sbuBXgH9jZhfN7OXW/pNJpzGzfw/8d+DH3P071dfuMLPvmNlZM3vZzO6asP63zOy/mtnfAZeBLdXXft3M/s7MLpjZX5rZqgm/c8Ptyfep0JP1I8AgsAr4GPB5M7MJy98N/DtgDRADn6y1QXf/C+A3ga+5+xJ3f33DU4t8388DjwFvcfddAGa2Dvgz4DeAlcB/BL5uZl0Tfu9dwEPAUuBg9bV/C7wXuAWYV/29ercnqNCTdtDdf9/dS8AXqRT36gnLn3T377n7JeC/AD9lZvkkgorcwNuA54B/mvDaO4Fn3P0Zdy+7+zeBXcC9E9Z5wt13u3vs7lH1tT9w9yF3vwI8BbxhBtsTVOhJOzb+wN0vVx8umbB8ZMLjg0BA5WheJC1+HugBPjfhr8tNwE9Wh0fOmtlZ4J9TOWAZN8JrHZvw+DLf/yzUsz0BCkkHkGltmPB4IxABJ4FLwKLxBdWj9ol/fuoSmtIqrwJvAf4a+J9UCn6Eyl+XPzvN781kH61ne4KO0NPunWbWZ2aLqIxTPl0dnhkCFpjZ280sAH4VmD/h914FujV7QFrB3Y9QKfW7zewTwJeAf21mP2ZmeTNbUP0if/0s36LR28ssfeDT7UngCSp/ii4AfhHA3c8B/wH4HHCYyhH7xFkvf1T931Nm9mKrwkrncvdDwJuBd1DZN++nMtvqBJUj7F9mln3j7iON3F6WmW5wkU5m9i3gS+7+uaSziEh70H/hREQyQoUuIpIRGnIREckIHaGLiGREYvPQV61a5d3d3Um9vWTcd7/73ZPunsip4dq3pZmm27cTK/Tu7m527dqV1NtLxpnZwdprNYf2bWmm6fZtDbmIiGSECl1EJCNU6CIiGaFCFxHJCBW6iEhGqNBFRDKiZqFXL1X5D9X7+O02s0enWGe+mX3NzIbN7Hkz625GWJFGMrMvmNlxM/veDZabmX2yul+/YmZvanVGkZmo5wj9GvDm6r0p30Dlmsd3TFrnfcAZd98GfAL47cbGFGmKJ4C7p1l+D7C9+vMQ8OkWZBKZtZqF7hUXq0+D6s/kC8DcT+WemABPA2+ZdLNjmYOxl1/m/Cc+gY+NJR0lU9z928DpaVa5H/jD6mfgOWC5mem2Z5JadZ0pWr3F2XeBbcDj7v78pFXWUb1HoLvHZnYOuJnK7dImbuchKkc6bNy4cW7JO8S5R78/wnX+t34LgGUf/WhScTrN9f26arT62tHJK9a7b//umd+d8vVHVjwyh5gzowzpyHCj959Lhrq+FHX3kru/AVgP3G5mPzSbN3P3z7r7be5+W1dXIpfZEGkK7duSBjOa5eLuZ4Fnee2442GqNzQ2swKwDDjViIAiCbq+X1etr74mkkr1zHLpMrPl1ccLgbcBA5NW2wn8dPXxO4C/cl1oXdrfTuDd1dkudwDn3P01wy0iaVHPGPoa4IvVcfQc8JS7/6mZPQbscvedwOeBJ81smMqXTA80LXEH8StXko6QaWb2FeAuYJWZjQIfpfKlP+7+GeAZ4F5gGLgMvDeZpCL1qVno7v4K8MYpXv/IhMdXgZ9sbDSJBgenfN1LJSyfb3Ga7HH3B2ssd+D9LYojMmc6UzTFojCc8vX4wIHWBhGRtqBCTym/do14794pl8U3KHoR6Wwq9JSK9uyBUmnqZQMDeLnc4kQiknYq9JSKwxBbvHjKZX7pEqWRkSmXiUjnUqGnkEcR0Z49BL29U6+QzxP197c2lIikngo9heK9eyGKCPr6plxe2LatMuyiqf4iMoEKPYWiMMQWLCC/adOUy4PeXvz8eUpHjrQ4mYikmQo9ZbxUIhocpNDbe8O55sGOHZDLadhFRH6ACj1l4v374do1gmLxhuvYwoUUNm8mDkMNu4jIdSr0lInCEObNo7Bly7TrBcUi5TNnKB8/3qJkIpJ2KvQU8XKZeGCAoKcHK0x/VYZCdQaMhl1EZJwKPUVKhw7hly9PO9wyLrd4MflNm254eQAR6Twq9BSJ+vuhUKCwbVtd6wfFIuUTJyidPFl7ZRHJPBV6Srg70cAAhW3bsHnz6vqd8SN5HaWLCKjQU6N0+DB+4UJdwy3jcjfdRH7dOl2sS0QAFXpqRP39kMsR9PTM6PeCYpHS0aOUz55tUjIRaRcq9BRwd6IwpLBlC7ZgwYx+t6BhFxGpUqGnQPnYMfzs2RkNt4zLr1xJbvVqFbqIqNDTIApDMKOwY8esfj8oFimNjFC+cKHByUSknajQUyAKQ/KbNpG7wfXPa7k+22VgoJGxRKTNqNATVjpxgvLJk7MabhmX6+oid/PNGnYR6XAq9ISNl/BcCt3MKsMuBw5Qvny5UdFEpM2o0BMWhSH59evJLV06p+0EfX3gTjw42KBkItJuVOgJKp85Q/nYsTkdnY/L3Xortny5hl1EOpgKPUGNGG4ZZ2YEvb3Ee/fiV6/OeXsi0n5qFrqZbTCzZ82s38x2m9kjU6xzl5mdM7OXqj8faU7cbInCkNytt5JbsaIh2wv6+qBcJhoaasj2RKS9TH/R7YoY+KC7v2hmS4Hvmtk33X3yhbj/xt1/vPERs6l8/jyl0VHm/6t/1bBt5tevx5YsIRoYYN4P/3DDtisi7aHmEbq7H3X3F6uPLwAhsK7ZwbJufM540NfXsG1eH3bZswcfG2vYdkWkPcxoDN3MuoE3As9PsfhHzexlM/tzM3vdDX7/ITPbZWa7Tpw4MeOwWRKFIbmuLvKrVjV0u0FfH8Qx8fBwQ7crIulXd6Gb2RLg68AH3P38pMUvApvc/fXA7wF/MtU23P2z7n6bu9/W1dU128xtr3zpEqWDBwmqt5FrpPymTdjChZrtItKB6ip0MwuolPmX3f2PJy939/PufrH6+BkgMLPGHnpmSDw4CO4NHW4ZZ7kchd5eoqEhPI4bvn0RSa96ZrkY8HkgdPeP32CdW6vrYWa3V7d7qpFBsyQKQ3IrVpBbvbop2w+KRRgbI963rynbF5F0qucI/U7gXcCbJ0xLvNfMfs7Mfq66zjuA75nZy8AngQfc3ZuUua351avE+/ZRKBap/jew4QqbN8P8+Rp2qYOZ3W1mg2Y2bGYfmmL5xuq03X80s1fM7N4kcorUo+a0RXf/W2Da5nH3TwGfalSoLIsGB6FcbsjJRDdihQJBTw/x4CBeKmH5fNPeq52ZWR54HHgbMAq8YGY7J03J/VXgKXf/tJn1Ac8A3S0PK1IHnSnaYlEYYkuXkl/X3JmfQbGIX7lC6eDBpr5Pm7sdGHb3fe4+BnwVuH/SOg7cVH28DDjSwnwiM6JCbyEfGyPeu5egicMt4wrbtkEQaNhleuuAkQnPR3ntORa/BrzTzEapHJ3/wlQb0pRcSQMVegvFe/ZAHDd1uGWcBQGFbduIBgbQ1xlz8iDwhLuvB+4FnjSz13xuNCVX0kCF3kJRGGKLFpHfuLEl7xcUi/jFi5RGRmqv3JkOAxsmPF9ffW2i9wFPAbj73wMLAE3JlVRSobeIxzHRnj0UenuxXGv+tQc9PZDPE/VPvuyOVL0AbDezzWY2D3gA2DlpnUPAWwDMrEil0DWmIqmkQm+ReO9eGBtryXDLOJs/n8LWrRp2uQF3j4GHgW9QuUbRU+6+28weM7P7qqt9EPjZ6pTcrwDv0ZRcSat6rrYoDRCFISxYUJkj3kJBby/x0BClo0cprF3b0vduB9Uzm5+Z9NpHJjzup3Iuhkjq6Qi9BbxUIh4cJOjpafmc8MKOHWBGrGEXkcxTobdAfOAAfvVqS4dbxuUWLaKweTNRGGrYRSTjVOgtEIchBAGFrVsTef9CsUj59GnKmh8tkmkq9CbzcploYKAy3BIEiWQYv0yvZruIZJsKvclKIyP4pUsUmnDt83rlliwhv3GjzhoVyTgVepNF/f2QzxNs355ojqBYpHz8OKVTuqqxSFap0JvI3YkGBihs24bNn59olvEvZGMdpYtklgq9iUpHjuDnzycyu2Wy3LJl5Neu1bCLSIap0Jso6u+HXK5yCn4KFIpFSkeOUD53LukoItIEKvQmcXfiMKSweTO2cGHScYDvD7voKF0km1ToTVJ+9VXKZ86kYrhlXP7mm8ndcosKXSSjVOhNMl6aSU5XnEpQLFI6dIjyxYtJRxGRBlOhN0kUhuQ3bSK3eHHSUX7A9WGXgYGEk4hIo6nQm6B08iTlEydSNdwyLnfLLeRWrtT0RZEMUqE3wfhwSxoL3cwIikXi/fspX76cdBwRaSAVehPEYUh+3TpyN91Ue+UEFIpFcCceGko6iog0kAq9wcpnz1I6ejSVR+fj8mvXYsuWabaLSMao0Bvs+uyWFBe6mVXuZLR3L37tWtJxRKRBVOgNFoUhudWrya9cmXSUaQV9fVAqEWnYRSQzaha6mW0ws2fNrN/MdpvZI1OsY2b2STMbNrNXzOxNzYmbbuULFyiNjKR6uGVcfv16bPFiTV8UyZB6jtBj4IPu3gfcAbzfzPomrXMPsL368xDw6YambBPj5dgOhW65XGXYZc8ePIqSjiMiDVCz0N39qLu/WH18AQiBdZNWux/4Q694DlhuZmsanjblojAkd/PN5Lq6ko5Sl6CvD6KIeHg46Sgi0gAzGkM3s27gjcDzkxatA0YmPB/ltaWPmT1kZrvMbNeJjN3f8tyjj1Lav5/yqVOcf+yxpOPUdO7RR7n05JMAXH7qKc49+mjCiURkruoudDNbAnwd+IC7n5/Nm7n7Z939Nne/ratNjmJFRNpFXYVuZgGVMv+yu//xFKscBjZMeL6++pqIiLRIPbNcDPg8ELr7x2+w2k7g3dXZLncA59z9aANzpppfvZp0BBERCnWscyfwLuCfzOyl6mu/AmwEcPfPAM8A9wLDwGXgvY2Pml5Zmcvt5TKW06kJIu2qZqG7+98CVmMdB97fqFDtJitzuUsHD1LYvDnpGCIySzocmyMfGyPesyfpGA2ha7uItDcV+hzFw8MQx0nHaIgoDKn8sSUi7UiFPkdRGKbmJtBz5RcvUhodTTqGiMySCn0OPI6JhoZSd9/QWcvlNOwi0sZU6HMQ79sHY2Ntce2WehS2bOm4YRczu9vMBqsXlvvQDdb5qQkXp/vfrc4oUi8V+hxEYQjz52dmZkhQLOJnz1I+dizpKC1hZnngcSoXl+sDHpx84Tkz2w58GLjT3V8HfKDlQUXqpEKfJS+ViAcHCXp6sEI90/nTr9DbC2ZE/f1JR2mV24Fhd9/n7mPAV6lcaG6inwUed/czAO5+vMUZReqmQp+l0sGD+JUrmRluAcgtWkS+uzsz8+rrUM9F5XqAHjP7OzN7zszublk6kRlSoc9SFIYQBBS2bUs6SkMFvb2UT56klLGrYc5Bgcp1/u8CHgR+38yWT14py1cSlfahQp8FdycaGKCwbRsWBEnHaajxvzg6ZNilnovKjQI73T1y9/3AEJWC/wG6kqikgQp9FkojI/jFi5kabhmXW7qU/IYNnTJ98QVgu5ltNrN5wANULjQ30Z9QOTrHzFZRGYLZ18qQIvVSoc9CFIaQzxP09CQdpSmCYpHyq69SOn066ShN5e4x8DDwDSp34nrK3Xeb2WNmdl91tW8Ap8ysH3gW+GV3P5VMYpHpZWN6Rgu5O1EYUtiyBZs/P+k4TRH09nL1L/+SOAzJ33ln0nGayt2foXK10ImvfWTCYwd+qfojkmo6Qp+h0tGj+LlzmRxuGZdbsYLcmjWdMuwikhkq9BmK+/vBjMKOHUlHaaqgWKR0+DDl87O626CIJECFPgPXh1s2bya3aFHScZrq+mwXHaWLtA0V+gyUT5ygfPp0di7GNY38qlXkurpU6CJtRIU+A+Nzs7M8fj5RUCxSOnSI8qVLSUcRkTqo0GcgCkPyGzeSW7Ik6SgtERSL4E7cOZcCEGlrKvQ6lU6donz8eMccnQPkVq8mt2KFhl1E2oQKvU5xtdQ6qdDNjEKxSLx/P37lStJxRKQGFXqdojAkv3YtuWXLko7SUkGxCOUy0dBQ0lFEpAYVeh3K585ROnKEQgcdnY/Lr1uH3XSThl1E2oAKvQ5RBw63jDMzgt5e4uFhfGws6TgiMg0Veh2iMCR3yy3kb7456SiJCPr6oFQi2rMn6SgiMo2ahW5mXzCz42b2vRssv8vMzpnZS9Wfj0y1XrsqX7xI6dChjjw6H5ffsAFbvPj6F8Mikk71HKE/AdS67dbfuPsbqj+PzT1Weozfjq2TC91yOYIdO4iGhvAoSjqOiNxAzUJ3928D2b4w9jTiMCS3ciW5W25JOkqiCn19EEXE+3RvB5G0atQY+o+a2ctm9udm9robrdRu910sX7lCfOAAQbGImSUdJ1GF7m5YsECzXURSrBGF/iKwyd1fD/welVt2Tand7rsYDw5CudyR0xUns3y+MuwyOIiXSknHEZEpzLnQ3f28u1+sPn4GCKr3Xmx7URhiy5aRX7s26SipEBSLcPUq8f79SUcRkSnMudDN7FarjkeY2e3Vbbb9PRf92jXivXsJens7frhlXGHrVpg3T7NdRFKq5j1FzewrVO56vsrMRoGPAgGAu38GeAfw82YWA1eAB6r3YWxr0Z49UCpV5mALAFYoEGzfTjQ4yIK3vx3L6TQGkTSpWeju/mCN5Z8CPtWwRCkRhSG2eDH59euTjpIqhWKRaPduSocOVb4oFZHU0CHWFDyKiPfsqQy36Cj0BwTbt0OhoNkuIimktppCvHcvRJGGW6Zg8+ZR2LqVKAzJwMiaSKao0KcQhSG2cCH5TZuSjpJKQbGIX7hA6fDhpKOIyAQq9Em8VCIaHKSwYweWzycdJ5WCnh7I5TTsIpIyKvRJ4n374Nq1jr52Sy22cCGFzZuJNewikioq9EmiMIR58yhs2ZJ0lFQLikXKZ85QfvXVpKOISJUKfQIvl4kHBwl6erBCzRmdHa3Q2wtmGnYRSREV+gSlgwfxy5c13FKH3OLF5DduVKGLpIgKfYIoDKFQoLBtW9JR2kJQLFI+cYLSyZNJRxERVOjXuTvRwACFbduwefOSjtMWxv+S0VG6SDqo0KtKo6P4hQsabpmB3E03kV+/XoUukhIq9KooDCGXq8yxlroFxSLlo0cpnzmTdBSRjqdCpzrcEoYUtmzBFixIOk5bafdhFzO728wGzWzYzD40zXo/YWZuZre1Mp/ITKjQgfKxY/jZsxpumYXcihXkbr31+s2024mZ5YHHgXuAPuBBM3vNBXzMbCnwCPB8axOKzIwKnerRpVllbrXMWFAsUhoZoXzhQtJRZup2YNjd97n7GPBV4P4p1vt14LeBq60MJzJTKnQqhZ7v7ia3aFHSUdpSGw+7rANGJjwfrb52nZm9Cdjg7n823Yba7Qbokk0dX+ilEyconzxJoKPzWct3dZFbtaodC31aZpYDPg58sNa67XYDdMmmji/08RLS+PncBMUipYMHKV++nHSUmTgMbJjwfH31tXFLgR8CvmVmB4A7gJ36YlTSSoUehuQ3bCC3dGnSUdpaUCyCO3F7fTn6ArDdzDab2TzgAWDn+EJ3P+fuq9y92927geeA+9x9VzJxRabX0YVePnOG8rFjOjpvgNytt2LLl7fVsIu7x8DDwDeAEHjK3Xeb2WNmdl+y6URmrqMvKRj19wNo/LwBzIygWGTs+efxq1fbZj6/uz8DPDPptY/cYN27WpFJZLY6+gg9Ghggt2YNuRUrko6SCUGxCOUy0dBQ0lFEOlLHFnr5/HlKo6Mabmmg/Pr12NKlbTXsIpIlHVvomt3SeGZG0NtLPDyMj40lHUek43R0oee6usivWpV0lEwJikWIY+Lh4aSjiHScjiz08qVLlA4d0tF5E+Q3bcIWLdKwi0gCaha6mX3BzI6b2fdusNzM7JPVq9W9Uj1VOtXigQFwV6E3geVyFHbsIBoawuM46TgiHaWeI/QngLunWX4PsL368xDw6bnHaq4oDCtXCVy9OukomRT09cHYGPG+fUlHEekoNQvd3b8NnJ5mlfuBP/SK54DlZramUQEbza9cId6/n0KxiJklHSeTCps3w/z5GnYRabFGjKHXvGLduKSvSHfu0Uc5/7GPQbnM2He+w7lHH215hk5w/jd+A65dI3rpJf07Fmmhln4pqivSiYg0TyMKvdYV60REpAUaUeg7gXdXZ7vcAZxz96MN2K5khJfLSUcQ6Qg1L85lZl8B7gJWmdko8FEgAHD3z1C5sNG9wDBwGXhvs8JKeyqNjlLYuDHpGCKZV7PQ3f3BGssdeH/DEjWJ5kQnJ+rvV6GLtEDHnCka792bdISOFQ0MUPnvvog0U8cUuuZEJ8fPnaN05EjSMUQyryMK3UslosHBpGN0rlyOWP9BFWm6jij0+MABuHo16Rgdq9DdTRSGGnYRabLOKPT+fgiCpGN0rEKxSPn0acrHjycdRSTTMl/oXi4TDQ4S9PQkHaVjjd+zVd9jiDRX5gu9NDKCX7pEQZfKTUxuyRLyGzeq0EWaLPOFHvX3Q6FAsH170lE6WlAsUj5+nNKpU0lHEcmsTBe6uxMNDFDYuhWbNy/pOB1t/GYiOkoXaZ5MF3rp8GH8/HndmSgFcsuWkV+7VtMXRZoo04UehSHkcvpCNCWCYpHSkSOUz51LOopIJmW20N2dOAwpbN6MLVyYdBwBCn19gIZdRJols4VefvVVymfOaLglRfIrV5JbvVqFLtIkmS30KAzBjEJ1DrSkQ9DbS+nQIcoXLyYdRSRzMl3o+Y0byS1enHQUmSAYH3YZGEg4iUj2ZLLQSydPUj5xQsMtKZTr6iJ3882a7SLSBJks9PExWhV6+pgZQbFIvH8/5cuXk44jkimZLfT8unXkbrop6SgyhUKxCO7EuqSxSENlrtDLZ89SPnpUR+cpll+zBlu2LBXj6GZ2t5kNmtmwmX1oiuW/ZGb9ZvaKmf0/M9uURE6RemSu0K8Pt1S/fJP0uT7ssncvfu1akjnywOPAPUAf8KCZTd5x/hG4zd1/GHga+FhrU4rUL5OFnrv1VnIrViQdRaYRFItQKhENDSUZ43Zg2N33ufsY8FXg/okruPuz7j4+2P8csL7FGUXqlqlCL1+4QGlk5Pr1tyW98hs2YEuWJH2S0TpgZMLz0eprN/I+4M+nWmBmD5nZLjPbdeLEiQZGFKlfpgp9fExWwy3pZ2YEvb3Ew8N4FCUdpyYzeydwG/A7Uy1398+6+23ufltXV1drw4lUZavQw5DcqlXk9YFqC0GxCFFEPDycVITDwIYJz9dXX/sBZvZW4D8D97l7coP+IjVkptDLly9TOnBAwy1tJL9pE7ZwYZLDLi8A281ss5nNAx4Adk5cwczeCPwvKmWum6JKqtVV6HVM7XqPmZ0ws5eqPz/T+KjTiwcGwF3DLW3E8nkKO3YQDQ3hcdzy93f3GHgY+AYQAk+5+24ze8zM7quu9jvAEuCPqvv2zhtsTiRxhVorTJja9TYqXxq9YGY73b1/0qpfc/eHm5CxLtHAALZ8Oblbb00qgsxCUCwSvfQS8f79idwm0N2fAZ6Z9NpHJjx+a8tDicxSPUfoNad2Jc2vXiXeu5egWMTMko4jM1DYsgXmzUt6totIJtRT6PVO7fqJ6tl0T5vZhimWN21qVzQ0BOWyzg5tQ1YoEPT0EA8M4OVy0nFE2lqjvhT9v0B39Wy6bwJfnGqlZk3tisIQW7qU/Hqd89GOgmIRv3KF0sGDSUcRaWv1FHrNqV3ufmrCdK7PAf+sMfFq87Ex4uFhgt5eDbe0qcK2bVAoaNhFZI7qKfR6pnatmfD0PiozBloiHh6GONZwSxuzefMobN9OFIa4e9JxRNpWzUKvc2rXL5rZbjN7GfhF4D3NCjxZFIbYwoXkN+kieO0s6O3FL16kNDqadBSRtlVz2iLUNbXrw8CHGxutjlxxTDQ0RPC612G5zJwj1ZGCnh6u5HJE/f0UNkz5nbqI1NDWLRjv2wdjYxpuyQBbsIDC1q1EAwMadhGZpbYu9CgMYf78ylxmaXtBsYifPUv52LGko4i0pbYtdC+ViAcHCXp6sHw+6TjSAIUdO8CMqH/yScgiUo+2LfTSwYP4lSsabsmQ3KJF5Lu7NdtFZJbattCjMIQgqMxhlswIikXKp05RPnky6SgibactC93diQYGKGzfjgVB0nGkgcYvf6xhF5GZa8tCL42M4Bcv6trnGZRbupT8hg06a1RkFtqy0KP+fsjnCXp6ko4iTRAUi5RffZXS6dNJRxFpK21X6NeHW7ZuxebPTzqONMH4F92xjtJFZqTtCr109Ch+7pxmt2RYbvly8mvWaNhFZIbartDj/n4wo6DhlkwrFIuUDh+mfP580lFE2kZbFbq7E4Uhhc2byS1alHQcaaLxv8B0lC5Sv7Yq9PKJE5RPn6ag4ZbMy69aRa6rS4UuMgNtVejjc5M1XbEzBMUipUOHKF+6lHQUkbbQXoUehuQ3biS3ZEnSUaQFgmIR3IkHBpKOItIW2qbQS6dOUT5+XLNbOkhu9WpyK1Zo2EWkTm1T6ONzklXoncPMKBSLxPv341euJB1HJPXaptCjMCS/di25ZcuSjiItFPT1QblMNDSUdBSR1GuLQi+fO0fpyBHNbulA+bVrsXYufxMAAAUcSURBVJtu0rCLSB3aotAjDbd0LDMj6O0lHh7Gr11LOo5IqrVNoeduuYX8zTcnHUUSEPT1QalENDycdBSRVEt9oZcvXqR06JCOzjtYfsMGbPFiXaxLpIbUF3pUnYOsQu9clssR7NhBNDSER1HScURSK/WFHochuZUryd1yS9JRJEGFvj6IIuK9e5OOIpJaqS708pUrxPv3ExSLmFnScSRBhe5ubMGC63+xichrpbrQ48FBcK8cnUlHs3yewo4dRIODeKmUdByRVKqr0M3sbjMbNLNhM/vQFMvnm9nXqsufN7PuRoSLwhBbtoz8mjWN2Jy0uaBYhKtXiffvb9g2k9q3RZqhZqGbWR54HLgH6AMeNLPJh8zvA864+zbgE8BvzzWYX7tGvHcvQW+vhlsEgMLWrTBvXsNOMkpq3xZplnqO0G8Hht19n7uPAV8F7p+0zv3AF6uPnwbeYnNs4WjPHiiVKnOQRQArFAi2byceGMDL5UZsMpF9W6RZzN2nX8HsHcDd7v4z1efvAn7E3R+esM73quuMVp/vra5zctK2HgIeqj7dAQzWyLcKOFljnbRR5uarJ+8md++aboWE9+16/zmaTRnaL8MN9+1CY/NMz90/C3y23vXNbJe739bESA2nzM2Xxrwz3bchHf8cypCtDPUMuRwGNkx4vr762pTrmFkBWAacmkswkRbQvi2ZUk+hvwBsN7PNZjYPeADYOWmdncBPVx+/A/grrzWWI5I87duSKTWHXNw9NrOHgW8AeeAL7r7bzB4Ddrn7TuDzwJNmNgycpvLBaIQZ/QmbEsrcfA3Jm/C+Den4964MFZnIUPNLURERaQ+pPlNURETqp0IXEcmI1BZ6rVOy08bMNpjZs2bWb2a7zeyRpDPVw8zyZvaPZvanSWeph5ktN7OnzWzAzEIz+9GkM81G0vu3mX3BzI5X59m3XBo+L2a2wMz+wcxermZ4tNUZJmRpyOcwlYVe5ynZaRMDH3T3PuAO4P1tkBngEaCd7hzxu8BfuHsv8HraKzuQmv37CeDuFr/nRGn4vFwD3uzurwfeANxtZne0OMO4hnwOU1no1HdKdqq4+1F3f7H6+AKV/3PWJZtqema2Hng78Lmks9TDzJYB/4LKzBPcfczdzyabalYS37/d/dtUZu0kIg2fF6+4WH0aVH9aPkukkZ/DtBb6OmBkwvNRUl6OE1WvyPdG4Plkk9T0P4D/BDTkwigtsBk4AfxB9c/Tz5nZ4qRDzUJb79+NluTnpTrU8RJwHPimuyfxmW3Y5zCthd62zGwJ8HXgA+5+Puk8N2JmPw4cd/fvJp1lBgrAm4BPu/sbgUtA6r9fkRtL+vPi7iV3fwOVs4RvN7MfauX7N/pzmNZCr+eU7NQxs4DKzvlld//jpPPUcCdwn5kdoPIn/5vN7EvJRqppFBidcBT1NJWCbzdtuX83Wpo+L9Whu2dp/fcKDf0cprXQ6zklO1Wql1T9PBC6+8eTzlOLu3/Y3de7ezeVf79/5e7vTDjWtNz9GDBiZjuqL70F6E8w0my13f7daGn4vJhZl5ktrz5eCLwNaOk9Dhv9OUxlobt7DIyfkh0CT7n77mRT1XQn8C4q/4V9qfpzb9KhMugXgC+b2StUZib8ZsJ5ZiwN+7eZfQX4e2CHmY2a2fta+f6k4/OyBni2ui+9QGUMvS2m796ITv0XEcmIVB6hi4jIzKnQRUQyQoUuIpIRKnQRkYxQoYuIZIQKXUQkI1ToIiIZ8f8BtnHTbXvcQdIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 定义输入信号与卷积核\n",
    "a = [0,1,2,3,2,1,0]\n",
    "# 方波信号\n",
    "k = [1,1,1,1,1]\n",
    "\n",
    "conv = conv_1d(a, k)\n",
    "conv.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "大家是否注意到，用一个方波信号对一个三角波信号进行卷积，其效果是将三角波变得平滑了。请大家记住这个现象，后续我们会再次提到。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 二维卷积"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在计算机视觉领域，我们常常需要对图像进行处理，而卷积则是一种常用的处理操作。一张数字图像可以看作一个二维空间的离散函数，表示为$\\mathbf{I}[i, j]$。与一维离散函数对应，我们可用矩阵表示图像这种二维离散函数。假设图像高为$H$，宽为$W$，设置卷积核$\\mathbf{K}[i,j]$，可以得到二维卷积的公式：\n",
    "$$\\mathbf{G}[i,j] = \\mathbf{I}[i,j] * \\mathbf{K}[i,j] = \\sum_{m=1}^{H}\\sum_{n=1}^{W}\\mathbf{I}[m,n]\\mathbf{K}[i-m,j-n]$$\n",
    "\n",
    "我们将卷积的概念从一维扩展到二维，其结果非常类似，只不过变成了矩阵的“卷和”操作。卷和就是离散的卷积，卷积是积分，而卷和是点与点的乘法和加法。一个二维图像 (矩阵) 同一个二维卷积核卷积的过程是这样的：\n",
    "1. 将二维卷积核对应的矩阵水平翻转，竖直翻转。\n",
    "2. 将这个卷积核矩阵与输入图像左上角对齐。\n",
    "3. 将卷积核矩阵的每一个元素，同输入图像中每一个对齐的元素相乘，再把所有的乘积加起来，并让这个卷积核矩阵在输入图像上滑动，重复上述计算。\n",
    "\n",
    "图 2-4 描述了二维卷积的计算过程。通过在输入图像上滑动，逐步得到整张图像的卷积输出：\n",
    "\n",
    "<center>\n",
    "    <img style=\"border-radius: 0.3125em;\" \n",
    "    src=\"https://storage.googleapis.com/kagglesdsdata/datasets/2171976/3643430/2w4.png?X-Goog-Algorithm=GOOG4-RSA-SHA256&X-Goog-Credential=databundle-worker-v2%40kaggle-161607.iam.gserviceaccount.com%2F20220522%2Fauto%2Fstorage%2Fgoog4_request&X-Goog-Date=20220522T053418Z&X-Goog-Expires=345599&X-Goog-SignedHeaders=host&X-Goog-Signature=9f2bfbf894a523d9ce4845f08f2d2fe57dd5296a6ebadd9ece3ea7b6a06f8b00fc7bc4462387336a5eed04b53125060eb7a739c277b9ce09287572859df897864df9c79ee1a31784ede5a27a308b18f3ae43bec9c8c602b59da0645d6263199d39cd6b6c162515c130c2ee7e5f2adf1db0983785c2a8b4350d810538a785aab9340cffcc3135770353773db73aa3c329bd3c12ee2c820937dba0aecbee0ef81ab11ad1eae918bdabde62416e5be9027055494506b88d3952e2ffaeb9e5bdde123785c1fbd496f8fb4f79c9fdb9b6850d8671ae72847c9216f1f9e938945f62c20c729a400cb5fb22c22b8dfc3886ed9ed84ad8f7960df0a17a30ccbbb3fa9694\" width=500>\n",
    "    <br>\n",
    "    <div style=\"color:orange; \n",
    "    display: inline-block;\n",
    "    color: #999;\n",
    "    padding: 2px;\">图2-4 二维卷积计算过程 </div>\n",
    "</center>\n",
    "\n",
    "不难发现，由于卷积核的大小限制，我们没法直接对左上角的像素点“1”进行卷积操作。因此，在计算最边缘的一行和一列的输出结果时，我们一般对原矩阵外围补零，再进行矩阵的卷和操作。\n",
    "\n",
    "<center>\n",
    "    <img style=\"border-radius: 0.3125em;\" \n",
    "    src=\"https://storage.googleapis.com/kagglesdsdata/datasets/2171976/3686018/2w3.png?X-Goog-Algorithm=GOOG4-RSA-SHA256&X-Goog-Credential=databundle-worker-v2%40kaggle-161607.iam.gserviceaccount.com%2F20220524%2Fauto%2Fstorage%2Fgoog4_request&X-Goog-Date=20220524T030513Z&X-Goog-Expires=345599&X-Goog-SignedHeaders=host&X-Goog-Signature=2703926ae985b3c105bb1c649eb4fe5c04818c34fef97aca8f962e10eb014ca7c7f918dab660da4dd3400f24375508d9e964660685cfc418a767bd14262c31468ba26c18512c0f17ed8057781891904cff9c3063b26a82566d1b31e79dcce1f2c49e16cb61e866b8601cb69f1c86f1229cf938dc0345db5f77fdfa678b1b1a587c4ec7e6090dd67dc55f508875ef07a0ac6d90c6a6d372774ed1737d15f40a1c26f604e7aec03d9a69165886be8d9abc713deff3618dda56d03ff011902ed2eef5096bfa51fc9f22616fc520215d1678b39725c8b099a8559217f0971ebbc88070564eae5cf316c41624293ece3ed6b7385e298528ea24f4134c1004ca76cd3d\" width=300>\n",
    "    <br>\n",
    "    <div style=\"color:orange; \n",
    "    display: inline-block;\n",
    "    color: #999;\n",
    "    padding: 2px;\">图2-5 图像补零后进行二维卷积 </div>\n",
    "</center>\n",
    "\n",
    "\n",
    "\n",
    "接下来，我们开始编写二维卷积。我们将对一张图像进行处理，并直观的展示卷积前后图像的变化。和一维卷积类似，我们也使用冲激信号和方波信号作为卷积核。大家注意代码中二维冲激信号和二维方波信号的实现。这里我们直接调用Python中的库函数（cv2.filter2D）进行二维卷积操作。我们把二维卷积的代码实现作为留给大家的习题，请大家自己完成。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-24T11:34:39.670572Z",
     "iopub.status.busy": "2022-05-24T11:34:39.670331Z",
     "iopub.status.idle": "2022-05-24T11:34:40.876823Z",
     "shell.execute_reply": "2022-05-24T11:34:40.875494Z",
     "shell.execute_reply.started": "2022-05-24T11:34:39.670539Z"
    }
   },
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import cv2\n",
    "import seaborn as sns\n",
    "\n",
    "class conv_2d():\n",
    "    def __init__(self, image, kernel):\n",
    "        self.img = image\n",
    "        self.k = kernel\n",
    "        \n",
    "    def plot(self):\n",
    "        # 展示原图\n",
    "        plt.figure()\n",
    "        plt.imshow(self.img[:, :, ::-1])\n",
    "        plt.axis('off')\n",
    "        plt.title('Input')\n",
    "        plt.show()   \n",
    "    \n",
    "    def plot_kernel(self):\n",
    "        sns.heatmap(self.k)\n",
    "        plt.axis('off')\n",
    "        plt.title('Kernel')\n",
    "        plt.show()   \n",
    "\n",
    "\n",
    "    # 定义二维卷积\n",
    "    def convolution(self, data, k):\n",
    "        # 直接调用库函数进行卷积操作\n",
    "        return cv2.filter2D(data, -1, k)\n",
    "\n",
    "    \n",
    "    # 展示二维卷积结果\n",
    "    def plot_conv(self):\n",
    "        img_new = self.convolution(self.img, self.k)  # 卷积过程\n",
    "        # 卷积结果可视化            \n",
    "        plt.figure()\n",
    "        plt.imshow(img_new[:, :, ::-1])\n",
    "        plt.title('Output')\n",
    "        plt.axis('off')\n",
    "        plt.show()\n",
    "        return\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了后续章节方便使用，我们将把上述代码导入utils.py文件中。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.1 冲激信号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-24T11:34:40.879227Z",
     "iopub.status.busy": "2022-05-24T11:34:40.878950Z",
     "iopub.status.idle": "2022-05-24T11:34:41.551923Z",
     "shell.execute_reply": "2022-05-24T11:34:41.551024Z",
     "shell.execute_reply.started": "2022-05-24T11:34:40.879195Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "img =cv2.imread('lena.jpeg')\n",
    "\n",
    "\n",
    "# 二维冲激卷积核\n",
    "size = 15\n",
    "k1 = np.zeros((size, size))\n",
    "mid = int((size-1) / 2)\n",
    "k1[mid][mid] = 1\n",
    "\n",
    "# 展示原图\n",
    "conv = conv_2d(img, k1)\n",
    "conv.plot()\n",
    "conv.plot_kernel()\n",
    "\n",
    "# 展示卷积结果\n",
    "conv.plot_conv()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由结果可见，用二维冲激函数对图像进行卷积，得到的结果和原图是一样的。这与我们在一维卷积中得到的结果一致。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.2 方波信号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-24T11:34:41.553330Z",
     "iopub.status.busy": "2022-05-24T11:34:41.553115Z",
     "iopub.status.idle": "2022-05-24T11:34:42.363693Z",
     "shell.execute_reply": "2022-05-24T11:34:42.363291Z",
     "shell.execute_reply.started": "2022-05-24T11:34:41.553304Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 二维方波卷积核\n",
    "size = 15\n",
    "k2 = 1/size/size * np.ones((size, size))\n",
    "\n",
    "# 展示原图\n",
    "conv = conv_2d(img, k2)\n",
    "conv.plot()\n",
    "conv.plot_kernel()\n",
    "\n",
    "# 展示卷积结果\n",
    "conv.plot_conv()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由结果可见，用方波信号作为卷积核，对图像做卷积，得到的结果是平滑模糊的图像，这也与我们在一维卷积中的实验结果一致。这是不是有一些图像处理的味道了？请大家记住这个结果，我们将在之后的章节中进一步阐述其原理。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 总结 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "卷积是信号处理领域的重要操作，也是计算机视觉中的必备技术。在图像处理中，卷积不仅考虑某一个像素点的影响，还考虑周围像素点对其的作用与影响，这也使得卷积操作为滤波技术奠定了基础。卷积除了一维和二维，同样也有高维的处理方式，感兴趣的同学可以自行查阅相关资料。\n",
    "\n",
    "在接下来的章节中，我们会进一步介绍卷积在图像处理中的作用。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 习题"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 习题 2.1：参照一维卷积的实现，编程实现二维卷积，基于该实现，完成以下任务：\n",
    "    \n",
    "    1. 计算图 2-4 中输入图像与卷积核卷积的结果（以矩阵表示）；\n",
    "    \n",
    "    2. 计算图 2-5 中补零后的输入图像与卷积核卷积的结果（以矩阵表示）；\n",
    "    \n",
    "    3. 重现2.3.1和2.3.2中对图像卷积的实验，并对比和用库函数得到的效果是否一致；\n",
    "    \n",
    "    4. 设计卷积核，通过卷积将一张图像往右下移动十个像素。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
